const messageService = require('../services/messageService');
const whatsappService = require('../services/whatsappService');
const config = require('../config');
const path = require('path');
const fs = require('fs');
const { MessageMedia } = require('whatsapp-web.js');

/**
 * 发送消息
 */
exports.sendMessage = async (req, res) => {
  try {
    const { contactId, content } = req.body;
    
    if (!contactId || !content) {
      return res.status(400).json({ message: '联系人ID和消息内容是必须的' });
    }
    
    // 添加详细日志
    console.log(`尝试向联系人 ${contactId} 发送消息，长度: ${content.length} 字符`);
    
    try {
      const result = await messageService.sendMessage(contactId, content, req.user);
      
      console.log(`消息发送成功，结果:`, result);
      
      // 确保返回一个一致的成功响应格式
      return res.json({
        success: true,
        messageId: result.id?.id || result.id || Date.now().toString(),
        timestamp: result.timestamp || new Date().toISOString(),
        status: result.ack || 'sent'
      });
    } catch (serviceError) {
      // 记录服务错误
      console.error(`向联系人 ${contactId} 发送消息失败:`, serviceError);
      
      // 返回格式化的错误响应
      return res.status(500).json({
        success: false,
        message: '发送消息失败，请检查WhatsApp连接状态',
        error: serviceError.message,
        contactId
      });
    }
  } catch (error) {
    console.error('发送消息处理请求出错:', error);
    console.error('错误堆栈:', error.stack);
    
    // 返回友好错误消息
    return res.status(500).json({ 
      success: false, 
      message: '发送消息出错',
      error: error.message
    });
  }
};

/**
 * 发送图片消息
 */
exports.sendImage = async (req, res) => {
  try {
    const { contactId, caption } = req.body;
    
    if (!contactId || !req.file) {
      return res.status(400).json({ message: '联系人ID和图片文件是必须的' });
    }
    
    // 读取上传的文件
    const filePath = req.file.path;
    const fileData = fs.readFileSync(filePath);
    const base64Data = fileData.toString('base64');
    
    // 创建MessageMedia对象
    const media = new MessageMedia(
      req.file.mimetype,
      base64Data,
      req.file.originalname
    );
    
    // 发送图片消息
    const result = await whatsappService.sendImage(contactId, media, caption || '');
    
    // 删除临时文件
    fs.unlinkSync(filePath);
    
    res.json({
      success: true,
      messageId: result.id.id,
      timestamp: result.timestamp
    });
  } catch (error) {
    console.error('发送图片出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 发送文件
 */
exports.sendFile = async (req, res) => {
  try {
    const { contactId, caption } = req.body;
    
    if (!contactId || !req.file) {
      return res.status(400).json({ message: '联系人ID和文件是必须的' });
    }
    
    // 读取上传的文件
    const filePath = req.file.path;
    const fileData = fs.readFileSync(filePath);
    const base64Data = fileData.toString('base64');
    
    // 创建MessageMedia对象
    const media = new MessageMedia(
      req.file.mimetype,
      base64Data,
      req.file.originalname
    );
    
    // 发送文件
    const result = await whatsappService.sendFile(contactId, media, caption || '');
    
    // 删除临时文件
    fs.unlinkSync(filePath);
    
    res.json({
      success: true,
      messageId: result.id.id,
      timestamp: result.timestamp,
      fileName: req.file.originalname
    });
  } catch (error) {
    console.error('发送文件出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 发送位置信息
 */
exports.sendLocation = async (req, res) => {
  try {
    const { contactId, latitude, longitude, description } = req.body;
    
    if (!contactId || !latitude || !longitude) {
      return res.status(400).json({ message: '联系人ID、纬度和经度是必须的' });
    }
    
    const result = await whatsappService.sendLocation(
      contactId,
      parseFloat(latitude),
      parseFloat(longitude),
      description || ''
    );
    
    res.json({
      success: true,
      messageId: result.id.id,
      timestamp: result.timestamp
    });
  } catch (error) {
    console.error('发送位置信息出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 发送预设文件
 */
exports.sendPresetFile = async (req, res) => {
  try {
    const { contactId, presetId } = req.body;
    
    if (!contactId || !presetId) {
      return res.status(400).json({ message: '联系人ID和预设文件ID是必须的' });
    }
    
    const result = await messageService.sendPresetFile(contactId, presetId, req.user);
    
    res.json(result);
  } catch (error) {
    console.error('发送预设文件出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 标记消息为已读
 */
exports.markAsRead = async (req, res) => {
  try {
    const { messageId } = req.params;
    
    if (!messageId) {
      return res.status(400).json({ message: '消息ID是必须的' });
    }
    
    const result = await whatsappService.markMessageAsRead(messageId);
    
    if (result) {
      res.json({ success: true, message: '消息已标记为已读' });
    } else {
      res.status(400).json({ success: false, message: '标记消息为已读失败' });
    }
  } catch (error) {
    console.error('标记消息为已读出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 标记聊天为已读
 */
exports.markChatAsRead = async (req, res) => {
  try {
    const { contactId } = req.params;
    
    if (!contactId) {
      return res.status(200).json({ 
        success: false, 
        message: '联系人ID是必须的',
        silentError: true
      });
    }
    
    // 记录入参日志
    console.log(`标记聊天为已读请求: 联系人ID=${contactId}`);
    
    // 格式化联系人ID，处理各种可能的ID格式
    let formattedContactId = contactId;
    
    // 如果是数字或仅包含数字，添加@c.us后缀
    if (/^\d+$/.test(contactId)) {
      formattedContactId = `${contactId}@c.us`;
      console.log(`已将纯数字ID ${contactId} 格式化为 ${formattedContactId}`);
    } 
    // 如果已经包含@c.us，保持原样
    else if (contactId.includes('@c.us')) {
      formattedContactId = contactId;
      console.log(`ID ${contactId} 已包含@c.us，无需格式化`);
    } 
    // 如果是复杂对象的JSON字符串，尝试解析
    else if (contactId.startsWith('{') && contactId.endsWith('}')) {
      try {
        const idObj = JSON.parse(contactId);
        if (idObj._serialized) {
          formattedContactId = idObj._serialized;
          console.log(`从JSON对象中提取序列化ID: ${formattedContactId}`);
        } else if (idObj.id) {
          formattedContactId = idObj.id;
          console.log(`从JSON对象中提取ID: ${formattedContactId}`);
        }
      } catch (e) {
        console.error(`解析复杂ID格式失败: ${e.message}`);
      }
    }
    
    console.log(`标记聊天为已读，使用格式化ID: ${formattedContactId}`);
    
    // 尝试使用多种方式标记为已读
    let result = false;
    try {
      // 先尝试直接用提供的ID标记
      result = await whatsappService.markChatAsRead(formattedContactId);
      console.log(`标记聊天${formattedContactId}为已读结果:`, result);
      
      // 如果失败，尝试使用原始ID
      if (!result && formattedContactId !== contactId) {
        console.log(`尝试使用原始ID ${contactId} 标记为已读`);
        result = await whatsappService.markChatAsRead(contactId);
        console.log(`使用原始ID标记结果:`, result);
      }
      
      // 尝试添加其他格式的ID
      if (!result && !contactId.includes('@')) {
        // 尝试添加@g.us格式（群组）
        const groupId = `${contactId}@g.us`;
        console.log(`尝试使用群组ID格式 ${groupId} 标记为已读`);
        result = await whatsappService.markChatAsRead(groupId);
        console.log(`使用群组ID格式标记结果:`, result);
      }
    } catch (markError) {
      console.error(`标记聊天为已读失败:`, markError);
      result = false;
    }
    
    // 返回结果
    if (result === true) {
      return res.status(200).json({ 
        success: true, 
        message: '聊天已标记为已读'
      });
    } else {
      return res.status(200).json({ 
        success: false, 
        message: '标记聊天为已读失败，但不影响使用',
        silentError: true,
        detail: '无法找到或标记该聊天'
      });
    }
  } catch (error) {
    // 记录错误日志
    console.error('标记聊天为已读出错:', error);
    console.error('错误堆栈:', error.stack);
    
    // 返回友好响应
    return res.status(200).json({ 
      success: false, 
      message: '标记聊天为已读时发生错误，但不影响使用',
      silentError: true,
      errorType: error.constructor.name
    });
  }
};

/**
 * 获取聊天历史记录
 */
exports.getChatHistory = async (req, res) => {
  try {
    const { contactId } = req.params;
    const limit = parseInt(req.query.limit) || 50;
    const beforeId = req.query.beforeId || null;
    
    // 添加请求日志
    console.log(`接收到获取聊天历史请求: contactId=${contactId}, limit=${limit}, beforeId=${beforeId}`);
    
    if (!contactId) {
      return res.status(400).json({ message: '联系人ID是必须的' });
    }
    
    // 检查limit范围
    if (limit < 1 || limit > 100) {
      return res.status(400).json({ message: '每页数量必须在1到100之间' });
    }
    
    try {
      // 添加beforeId参数用于分页加载
      const messages = await whatsappService.getChatHistory(contactId, limit, beforeId);
      
      // 添加结果日志
      console.log(`成功获取到${messages?.length || 0}条聊天历史记录`);
      
      // 如果没有消息，返回空数组而不是错误
      if (!messages || messages.length === 0) {
        console.log(`聊天${contactId}没有历史记录`);
        return res.json([]);
      }
      
      // 对消息进行初步检查
      if (messages[0]) {
        console.log(`首条消息示例:`, JSON.stringify(messages[0], (key, value) => {
          // 缩短过长的字段显示
          if (typeof value === 'string' && value.length > 100) {
            return value.substring(0, 100) + '...';
          }
          return value;
        }));
      }
      
      // 处理每条消息，确保每条消息都有正确的结构
      const processedMessages = messages.map((message, index) => {
        if (!message) {
          console.warn(`消息 #${index} 为null，跳过处理`);
          return null;
        }
        
        try {
          // 构建标准消息对象
          const standardMsg = {
            id: message.id || `temp_${Date.now()}_${index}`,
            content: typeof message.body === 'string' ? message.body : 
                    (typeof message.content === 'string' ? message.content : '内容不可用'),
            timestamp: message.timestamp || new Date().toISOString(),
            direction: message.fromMe ? 'outbound' : 'inbound',
            fromMe: !!message.fromMe,
            sender: { 
              id: message.from?.id || (message.fromMe ? 'me' : contactId),
              name: message.fromMe ? '我' : (message.from?.name || '联系人') 
            },
            type: message.type || 'text',
            hasSensitive: message.hasSensitiveContent || false,
            status: message.status || 'sent'
          };
          
          // 根据用户角色处理敏感信息
          if (req.user && req.user.role !== 'admin') {
            // 非管理员用户看不到敏感内容
            if (standardMsg.hasSensitive) {
              standardMsg.content = '该内容含有敏感信息，已被系统隐藏';
              standardMsg._sensitive = true;
            }
            
            // 隐藏电话号码等敏感标识符
            if (standardMsg.content && typeof standardMsg.content === 'string') {
              // 使用正则表达式替换电话号码格式
              standardMsg.content = standardMsg.content.replace(/\d{6,}/g, match => {
                return match.substring(0, 3) + '****' + match.substring(match.length - 2);
              });
            }
          }
          
          return standardMsg;
        } catch (msgError) {
          console.error(`处理消息 #${index} 时出错:`, msgError);
          // 返回简化的错误消息
          return {
            id: `error_${Date.now()}_${index}`,
            content: '消息解析失败',
            timestamp: new Date().toISOString(),
            direction: 'system',
            fromMe: false,
            type: 'system',
            error: true
          };
        }
      }).filter(Boolean); // 过滤掉null值
      
      console.log(`处理后返回${processedMessages.length}条有效消息`);
      
      res.json(processedMessages);
    } catch (error) {
      console.error('获取聊天历史出错:', error);
      console.error('错误堆栈:', error.stack);
      // 返回空数组而不是错误状态码
      res.json([]);
    }
  } catch (error) {
    console.error('获取聊天历史处理请求出错:', error);
    console.error('错误堆栈:', error.stack);
    // 错误时也返回空数组
    res.json([]);
  }
};

/**
 * 搜索消息
 */
exports.searchMessages = async (req, res) => {
  try {
    const { query, contactId } = req.query;
    
    if (!query) {
      return res.status(400).json({ message: '搜索关键词是必须的' });
    }
    
    // 如果提供了联系人ID，则在特定聊天中搜索
    if (contactId) {
      try {
        const chat = await whatsappService.getChatById(contactId);
        if (!chat) {
          return res.status(404).json({ message: '聊天不存在' });
        }
        
        const messages = await chat.searchMessages(query, { limit: 20 });
        
        // 根据用户角色处理消息
        const processedMessages = messages.map(message => {
          const processedMsg = messageService.processIncomingMessage(message);
          return messageService.processMessageForRole(processedMsg, req.user.role);
        });
        
        res.json(processedMessages);
      } catch (error) {
        console.error('搜索特定聊天消息出错:', error);
        res.status(404).json({ message: '搜索特定聊天消息失败', error: error.message });
      }
    } else {
      // 全局搜索消息（未实现，返回空数组）
      res.json([]);
    }
  } catch (error) {
    console.error('搜索消息出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
}; 